CPP模版,从精通到精神分裂

// 第一段程序
#include <iostream>
#include <vector>
using namespace std;
class Animal{
public:
    virtual void talk() = 0;
};
class Cat :public Animal{
public:
    virtual void talk(){cout<<"Miao\n";}
};
class Developer: public Animal{
public: 
    virtual void talk(){cout<<"Hello world\n";}
};
void LetAnimalTalk(Animal* pa){
    pa->talk(); 
}
int main(){
    Developer* pd = new Developer();
    Cat* pc = new Cat();
    LetAnimalTalk(pd);
    LetAnimalTalk(pc);
    vector<Animal*> va;
    va.push_back(pd);
    va.push_back(pc);
    system("pause");
    return 0;
}
/*
Hello world
Miao
*/
这是一个教科书般经典的例子。介绍C++的继承和多态。这里唯一需要重点强调的是:对函数LetAnimalTalk和vector va 来说,我们可以想象他们是客户。[face=黑体]通过继承把变化封装到基类的后面,这样使用基类接口的客户就不需要改动![/face]对客户来说,无论基类后面怎么变化,你都影响不到我。例如,如果现在有一个经理狗加入了项目团队,你的LetAnimalTalk函数是不需要任何改变的。 So far so good! 现在看看引入模版后,发生了什么?
//第二段程序
#include <iostream>
#include <vector>
using namespace std;
template< typename T>
class Animal{
 public:
     T id_;
     Animal(T t){id_ = t;};
     virtual void talk() = 0;
};
template<typename T>
class Cat :public Animal<T>{
 public:
     Cat(T t):Animal<T>(t){};
     virtual void talk(){cout<<"Miao, I am "<<Animal<T>::id_ <<"\n";}
};
template<typename T>
class Developer: public Animal<T>{
 public: 
     Developer(T t):Animal<T>(t){};
     virtual void talk()
     {
         cout<<"Hello world, I am "<<Animal<T>::id_ <<"\n";}
};
template<typename T>
void LetAnimalTalk(Animal<T>* pa){
    pa->talk(); 
}
int main()
{
    Developer<string>* pd = new Developer<string>("Yan");
    Cat<string>* pc = new Cat<string>("Fluffy");
    LetAnimalTalk(pd);
    LetAnimalTalk(pc);
    vector<Animal<string>*> va;
    va.push_back(pd);
    va.push_back(pc);
    system("pause");
    return 0;
}
/* vc6 no ,cpp.sh ok
Hello world, I am Yan
Miao, I am Fluffy
*/

基本的应用场景是这样的。对于animal, 你可以用字符串来表示他的ID, 如果你想developer是不应该享有字符串名字的,那么你也可以用整型数来表示他的ID。上面整个的程序,如果你把main中换成下面的样子,除了猫会有点意见,其它一切都没有问题!

int main()
{
    Developer<int>* pd = new Developer<int>(9527);
    Cat<int>* pc = new Cat<int>(1234);
    LetAnimalTalk(pd);
    LetAnimalTalk(pc);
    vector<Animal<int>*> va;
    va.push_back(pd);
    va.push_back(pc);
    
    system("pause");
    return 0;
}
/* 
Hello world, I am 9527
Miao, I am 1234
*/

上面模版继承的一个最明显的弊端是语法变得更加臃肿和复杂了。例如,你不可能在子类中直接引用基类的变量了。如果你引用他,必须使用Animal::id_这样的语法。背后的原因是当编译器编译Cat的时候,Animal是根本不存在的!具体的细节你可以看后面的参考文献1。

另外的一个问题就是虚函数的效率问题。这种多态是发生在程序运行的时候,主要通过虚函数表进行调用分发。所以有一定的效率损失。下面我们再看另外一个例子。由于猫不喜欢整型ID的名字,所以我们这里完全去掉这个feature,重点关注如何利用模版实现多态。

//第三段程序
 #include <iostream>
#include <vector>
using namespace std;
template< typename T>
class Animal{
 public:
     void talk(){static_cast<T*>(this)->talkImplement();}
};
class Cat :public Animal<Cat>{
public:
    void talkImplement(){cout<<"Miao \n";}
};
class Developer: public Animal<Developer>{
public:
    void talkImplement(){cout<<"Hello world \n";}
};
template<typename T>
void LetAnimalTalk(Animal<T>& pa){
    pa.talk(); 
}
int main(){
    Developer pd;
    Cat pc;
    LetAnimalTalk(pd);
    LetAnimalTalk(pc);
    vector<Animal<Cat> > va;
    va.push_back(pc); // OK
    // va.push_back(pd); // compile error here
    
    system("pause");
    return 0;
}
/*
Hello world
Miao
*/

这段代码中,有几点注意一下:

1) 多态已经不需要用指针了,我们可以用引用来支持多态。

2)在函数LetAnimalTalk中,pa.talk()到底调用那一个 talkImplement是在编译的时候就决定了。这是一种静态多态技术。所以没有效率的损失。

3)但是函数LetAnimalTalk现在必须是模版函数,同时我们也失去了用vector同时保存Cat 和Developer的能力。这是效率提升带来的灵活性的损失!

4)这个是CRTP模式,更多介绍看参考文献2。翻译过来就是“好奇地不断追问自己!”这应该是一种精神分裂的明显的初期症状了。

目前为止,我们介绍了三个例子。还都遵循着一个基本的IS-A的逻辑关系。也就是说,Cat是一个Animal,Developer也是一个Animal。下面介绍三个IMPLEMENT-BY的逻辑关系。第一个例子完全没有使用继承。

//第四段程序
#include <iostream>
#include <vector>
using namespace std;
template< typename T>
class Animal{
 private:
     T t;
 public:
     void talk(){t.talkImplement();}
};
class SayMiao {
public:
    void talkImplement(){cout<<"Miao \n";}
};
class SayHW{
public:
    void talkImplement(){cout<<"Hello world \n";}
};
template<typename T>
void LetAnimalTalk(Animal<T>& pa){
    pa.talk(); 
}
int main(){
    Animal<SayMiao> am;
    Animal<SayHW> ah;
    LetAnimalTalk(am);
    LetAnimalTalk(ah);
    vector<Animal<SayMiao> > va;
    va.push_back(am); // OK
    //va.push_back(ah); // compile error here
    system("pause");
    return 0;
}
/*
Miao
Hello world
*/

1) 这段程序中,通过模版参数,在编译的时候就把不同的talk行为的实现方式传递给Animal类。这个方法在STL中运用的相当广泛。具体的例子像STL中的map类

template<
 class Key,
 class T,
 class Compare = std::less<Key>,
 class Allocator = std::allocator<std::pair<const Key, T> >
> class map;

其中, std::less就类似于我们上面的SayMiao。

2)由于导入的是某种行为,所有再叫做Cat就不合适了,所以这里把类的名字叫做SayMiao

为了实现IMPLEMENT-BY关系,我们也可以使用私有继承:

//第五段程序
 #include <iostream>
using namespace std;
#include <vector>
template< typename T>
class Animal: private T{
 public:
     void talk(){T::talkImplement();}
};
class SayMiao {
public:
    void talkImplement(){cout<<"Miao \n";}
};
class SayHW{
public:
    void talkImplement(){cout<<"Hello world \n";}
};
template<typename T>
void LetAnimalTalk(Animal<T>& pa){
    pa.talk(); 
}
int main(){
    Animal<SayMiao> am;
    Animal<SayHW> ah;
    LetAnimalTalk(am);
    LetAnimalTalk(ah);
    vector<Animal<SayMiao> > va;
    va.push_back(am); // OK
    //va.push_back(ah); // compile error here
    system("pause");
    return 0;
}
/*
Miao
Hello world
*/

1) 有没有被

template

class Animal: private T{

这样的语法惊到!没关系,我们慢慢来。首先私有继承不是IS-A的关系。而是IMPLEMENT-BY的关系。关于什么时候使用私有继承,什么时候使用组合(composition)。请看参考文献3。

2)这种方式是Parameterised inheritance, 也是一种常见的设计模式,请看参考文献4

OK,最后的问题是,既然私有继承可以,共有继承行不行?在一个分裂的病人眼中,没啥是不行的!

//第六段程序
#include <iostream>
using namespace std;
#include <vector>
template< typename T>
class Animal: public T{
};
class SayMiao {
public:
    void talk(){cout<<"Miao \n";}
};
class SayHW{
public:
    void talk(){cout<<"Hello world \n";}
};
template<typename T>
void LetAnimalTalk(Animal<T>& pa){
    pa.talk(); 
}
int main(){
    Animal<SayMiao> am;
    Animal<SayHW> ah;
    LetAnimalTalk(am);
    LetAnimalTalk(ah);
    vector<Animal<SayMiao> > va;
    va.push_back(am); // OK
    //va.push_back(ah); // compile error here
    system("pause");
    return 0;
}
/*
Miao
Hello world
*/

1) 这就是在Modern C++ design中提到的Policy-Based design。一个小提示是:现在在Animal中已经不需要talk这个函数了。

上面我一共给出了六个程序。到 https://www.onlinegdb.com/ 把这六段代码拷贝进去,根据自己的理解和问题修改一下。“纸上得来终觉浅,绝知此事要运行”。这其实是陆游给广大程序猿的一句忠告。如果你有足够的耐心,你可以慢慢地深入的体会,这里好玩的东西还挺多的。由于篇章关系(主要是再展开我也不会了!)我就不多说了。

以上这六段程序,分别代表着六种不同的语法方式,表达出两种最基本的设计模式 IS-A还是IMPLEMENT-BY。首先,没有什么优劣之分,在不同的场景下,各有优缺点。另外,C++的模版完全不同于传统的C++编程。他的语法和想表达的语义有非常明显的分裂趋势,非常容易把传统的C++程序猿也搞分裂了。正所谓范型是C++最大的坑,但是不跳此坑,不足以谈人生!

本页共303段,6878个字符,9917 Byte(字节)